/**
 * @file system_utils.c
 * @brief 系统初始化和工具函数实现
 * @version 2.0
 * @date 2023-05-20
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <libavformat/avformat.h>
#include <libavutil/log.h>
#include <sys/statvfs.h>
#include "system_utils.h"
#include "common_defs.h"
#include "thread_utils.h"

// 标记未使用的变量或函数，避免编译警告
#define UNUSED(x) (void)(x)

// 全局配置
SystemConfig g_system_config = {
    .log_level = LOG_LEVEL_INFO,
    .log_file = "ice_monitor.log",
    .console_log = true,
    .simulation_mode = false,
    .sampling_interval_ms = 1000, // 默认1秒
    .work_dir = ".",
    .config_file = "config.ini"
};

// 全局运行标志
extern volatile bool g_running;  // 定义在app_control.c中

// 日志文件句柄
static FILE *log_file_handle = NULL;

// 前向声明
static void signal_handler(int sig);
static void print_usage(const char *prog_name);
int init_system(int argc, char **argv);

// 日志级别字符串
static const char *log_level_str[] = {
    "无",
    "错误",
    "警告",
    "信息",
    "调试",
    "跟踪"
};

// 从logger.c合并的日志系统状态
static struct {
    FILE* log_file;            // 日志文件句柄
    bool console_output;       // 是否输出到控制台
    LogLevel min_level;        // 最低记录的日志级别
    bool initialized;          // 是否已初始化
} g_logger = {NULL, true, LOG_LEVEL_INFO, false};

/**
 * @brief 获取当前时间戳字符串（从logger.c合并）
 * 
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 */
static void get_timestamp(char* buffer, size_t size) {
    struct timeval tv;
    struct tm* tm_info;
    
    gettimeofday(&tv, NULL);
    tm_info = localtime(&tv.tv_sec);
    
    strftime(buffer, size, "%Y-%m-%d %H:%M:%S", tm_info);
    
    // 添加毫秒
    char ms_buffer[8];
    snprintf(ms_buffer, sizeof(ms_buffer), ".%03ld", tv.tv_usec / 1000);
    strncat(buffer, ms_buffer, size - strlen(buffer) - 1);
}

void set_log_level(LogLevel level) {
    if (level <= LOG_LEVEL_TRACE) {
        g_system_config.log_level = level;
        
        // 同时设置FFmpeg日志级别
        switch (level) {
            case LOG_LEVEL_NONE:
                av_log_set_level(AV_LOG_QUIET);
                break;
            case LOG_LEVEL_ERROR:
                av_log_set_level(AV_LOG_ERROR);
                break;
            case LOG_LEVEL_WARNING:
                av_log_set_level(AV_LOG_WARNING);
                break;
            case LOG_LEVEL_INFO:
                av_log_set_level(AV_LOG_INFO);
                break;
            case LOG_LEVEL_DEBUG:
                av_log_set_level(AV_LOG_DEBUG);
                break;
            case LOG_LEVEL_TRACE:
                av_log_set_level(AV_LOG_TRACE);
                break;
        }
        
        // 更新g_logger的min_level以保持兼容性
        g_logger.min_level = level;
    }
}

void log_message(LogLevel level, const char *format, ...) {
    if (level < g_system_config.log_level) {
        return;
    }
    
    // 获取当前时间
    time_t now;
    struct tm tm_info;
    char time_str[30];
    
    time(&now);
#ifdef _WIN32
    localtime_s(&tm_info, &now);
#else
    localtime_r(&now, &tm_info);
#endif
    
    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", &tm_info);
    
    // 日志级别字符串
    const char *level_str;
    switch (level) {
        case LOG_LEVEL_DEBUG:
            level_str = "DEBUG";
            break;
        case LOG_LEVEL_INFO:
            level_str = "INFO ";
            break;
        case LOG_LEVEL_WARNING:
            level_str = "WARN ";
            break;
        case LOG_LEVEL_ERROR:
            level_str = "ERROR";
            break;
        default:
            level_str = "UNKNOWN";
            break;
    }

    // 格式化消息
    va_list args;
    va_start(args, format);
    char message[1024];
    vsnprintf(message, sizeof(message), format, args);
    va_end(args);

    // 构建完整日志消息
    char full_message[1024 + 128];
    snprintf(full_message, sizeof(full_message), "[%s][%s] %s\n", 
             time_str, level_str, message);

    // 输出到控制台
    if (g_system_config.console_log) {
        if (level == LOG_LEVEL_ERROR) {
            fprintf(stderr, "\033[1;31m%s\033[0m", full_message); // 红色
        } else if (level == LOG_LEVEL_WARNING) {
            fprintf(stderr, "\033[1;33m%s\033[0m", full_message); // 黄色
        } else {
            fprintf(stdout, "%s", full_message);
        }
    }

    // 输出到日志文件
    if (log_file_handle) {
        fprintf(log_file_handle, "%s", full_message);
        fflush(log_file_handle);
    }
    
    // 支持旧的logger接口
    if (g_logger.log_file != NULL && g_logger.log_file != log_file_handle) {
        fprintf(g_logger.log_file, "%s", full_message);
        fflush(g_logger.log_file);
    }
}

/**
 * @brief 初始化日志系统（从logger.c合并）
 * 
 * @param log_file 日志文件路径，NULL表示仅输出到控制台
 * @param console_output 是否同时输出到控制台
 * @param min_level 最低记录的日志级别
 * @return int 成功返回0，失败返回非0值
 */
int init_logger(const char* log_file, bool console_output, LogLevel min_level) {
    // 如果已初始化，先关闭
    if (g_logger.initialized) {
        cleanup_logger();
    }
    
    g_logger.console_output = console_output;
    g_logger.min_level = min_level;
    
    // 更新system_utils配置以保持同步
    g_system_config.console_log = console_output;
    g_system_config.log_level = min_level;
    
    // 打开日志文件
    if (log_file != NULL) {
        g_logger.log_file = fopen(log_file, "a");
        if (g_logger.log_file == NULL) {
            fprintf(stderr, "无法打开日志文件: %s\n", log_file);
            return -1;
        }
        
        // 同时更新system_utils的日志文件
        if (log_file_handle == NULL) {
            log_file_handle = g_logger.log_file;
        }
    } else {
        g_logger.log_file = NULL;
    }
    
    g_logger.initialized = true;
    
    // 记录初始化信息
    log_message(LOG_LEVEL_INFO, "日志系统初始化完成");
    
    return 0;
}

/**
 * @brief 关闭日志系统（从logger.c合并）
 */
void cleanup_logger(void) {
    static bool already_cleaned = false;
    
    if (!g_logger.initialized || already_cleaned) {
        return;
    }
    
    already_cleaned = true;
    
    // 记录关闭信息
    log_message(LOG_LEVEL_INFO, "日志系统关闭");
    
    // 关闭文件
    if (g_logger.log_file != NULL) {
        // 如果g_logger.log_file与log_file_handle相同，避免重复关闭
        if (g_logger.log_file == log_file_handle) {
            log_file_handle = NULL;
        }
        fclose(g_logger.log_file);
        g_logger.log_file = NULL;
    }
    
    g_logger.initialized = false;
}

int init_system(int argc, char **argv) {
    // 解析命令行参数
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
            print_usage(argv[0]);
            return 1;
        } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
            set_log_level(LOG_LEVEL_DEBUG);
        } else if (strcmp(argv[i], "-q") == 0 || strcmp(argv[i], "--quiet") == 0) {
            g_system_config.console_log = false;
        } else if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--simulation") == 0) {
            g_system_config.simulation_mode = true;
        } else if (strcmp(argv[i], "-l") == 0 || strcmp(argv[i], "--log") == 0) {
            if (i + 1 < argc) {
                strncpy(g_system_config.log_file, argv[++i], sizeof(g_system_config.log_file) - 1);
                g_system_config.log_file[sizeof(g_system_config.log_file) - 1] = '\0'; // 确保null结尾
            }
        } else if (strcmp(argv[i], "-c") == 0 || strcmp(argv[i], "--config") == 0) {
            if (i + 1 < argc) {
                strncpy(g_system_config.config_file, argv[++i], sizeof(g_system_config.config_file) - 1);
                g_system_config.config_file[sizeof(g_system_config.config_file) - 1] = '\0'; // 确保null结尾
            }
        } else if (strcmp(argv[i], "-i") == 0 || strcmp(argv[i], "--interval") == 0) {
            if (i + 1 < argc) {
                g_system_config.sampling_interval_ms = atoi(argv[++i]);
                if (g_system_config.sampling_interval_ms < 100) {
                    g_system_config.sampling_interval_ms = 100; // 最小100毫秒
                }
            }
        } else if (strcmp(argv[i], "-d") == 0 || strcmp(argv[i], "--dir") == 0) {
            if (i + 1 < argc) {
                strncpy(g_system_config.work_dir, argv[++i], sizeof(g_system_config.work_dir) - 1);
                g_system_config.work_dir[sizeof(g_system_config.work_dir) - 1] = '\0'; // 确保null结尾
            }
        }
    }

    // 设置工作目录
    if (strcmp(g_system_config.work_dir, ".") != 0) {
        if (chdir(g_system_config.work_dir) != 0) {
            fprintf(stderr, "无法切换到工作目录: %s\n", g_system_config.work_dir);
            return -1;
        }
    }
    
    // 获取当前工作目录
    char cwd[256];
    if (get_current_dir(cwd, sizeof(cwd)) == 0) {
        strncpy(g_system_config.work_dir, cwd, sizeof(g_system_config.work_dir) - 1);
        g_system_config.work_dir[sizeof(g_system_config.work_dir) - 1] = '\0'; // 确保字符串以null结尾
    }

    // 打开日志文件
    log_file_handle = fopen(g_system_config.log_file, "a");
    if (!log_file_handle) {
        fprintf(stderr, "无法打开日志文件: %s\n", g_system_config.log_file);
        // 继续执行，只是不写日志文件
    }

    // 设置信号处理
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    signal(SIGPIPE, SIG_IGN); // 忽略管道错误信号

    // 初始化FFmpeg网络功能
    avformat_network_init();

    // 设置FFmpeg日志级别
    switch (g_system_config.log_level) {
        case LOG_LEVEL_NONE:
            av_log_set_level(AV_LOG_QUIET);
            break;
        case LOG_LEVEL_ERROR:
            av_log_set_level(AV_LOG_ERROR);
            break;
        case LOG_LEVEL_WARNING:
            av_log_set_level(AV_LOG_WARNING);
            break;
        case LOG_LEVEL_INFO:
            av_log_set_level(AV_LOG_INFO);
            break;
        case LOG_LEVEL_DEBUG:
            av_log_set_level(AV_LOG_DEBUG);
            break;
        case LOG_LEVEL_TRACE:
            av_log_set_level(AV_LOG_TRACE);
            break;
    }

    // 创建数据存储目录
    char data_dir[256];
    size_t base_len = strlen(g_system_config.work_dir);
    
    // 确保有足够空间存储路径加/data
    if (base_len + 6 <= sizeof(data_dir)) { // +6 用于 "/data" 和 null终止符
        snprintf(data_dir, sizeof(data_dir), "%s/data", g_system_config.work_dir);
        create_directory(data_dir);
    } else {
        log_message(LOG_LEVEL_WARNING, "工作目录路径过长，无法创建数据目录");
    }

    // 打印系统信息
    print_system_info();

    // 记录初始化日志
    log_message(LOG_LEVEL_INFO, "系统初始化完成，工作目录: %s", g_system_config.work_dir);
    log_message(LOG_LEVEL_INFO, "运行模式: %s", g_system_config.simulation_mode ? "模拟模式" : "实际模式");

    return 0;
}

// 原来的cleanup_system重命名为internal_cleanup_system，避免与main.c中的函数冲突
static void internal_cleanup_system(void) {
    static bool already_cleaned = false;
    
    if (already_cleaned) {
        return;
    }
    
    already_cleaned = true;
    
    // 记录清理日志
    log_message(LOG_LEVEL_INFO, "系统正在清理资源...");

    // 关闭日志文件
    if (log_file_handle) {
        fclose(log_file_handle);
        log_file_handle = NULL;
    }

    // 清理FFmpeg网络功能
    avformat_network_deinit();

    // 可以在这里添加其他清理工作
}

void print_system_info(void) {
    // 获取系统信息
    char hostname[256];
    gethostname(hostname, sizeof(hostname));

    // 打印系统信息
    log_message(LOG_LEVEL_INFO, "======= 系统信息 =======");
    log_message(LOG_LEVEL_INFO, "主机名: %s", hostname);
    log_message(LOG_LEVEL_INFO, "工作目录: %s", g_system_config.work_dir);
    log_message(LOG_LEVEL_INFO, "日志文件: %s", g_system_config.log_file);
    log_message(LOG_LEVEL_INFO, "日志级别: %s", log_level_str[g_system_config.log_level]);
    log_message(LOG_LEVEL_INFO, "运行模式: %s", g_system_config.simulation_mode ? "模拟模式" : "实际模式");
    log_message(LOG_LEVEL_INFO, "采样间隔: %d 毫秒", g_system_config.sampling_interval_ms);
    log_message(LOG_LEVEL_INFO, "========================");
}

static void print_usage(const char *prog_name) {
    printf("覆冰监测控制器\n");
    printf("用法: %s [选项]\n", prog_name);
    printf("选项:\n");
    printf("  -h, --help       显示此帮助信息\n");
    printf("  -v, --verbose    启用详细日志输出\n");
    printf("  -q, --quiet      禁用控制台日志输出\n");
    printf("  -s, --simulation 以模拟模式运行\n");
    printf("  -l, --log FILE   指定日志文件 (默认: ice_monitor.log)\n");
    printf("  -c, --config FILE 指定配置文件 (默认: config.ini)\n");
    printf("  -i, --interval MS 设置采样间隔 (毫秒, 默认: 1000)\n");
    printf("  -d, --dir PATH   设置工作目录\n");
}

static void signal_handler(int sig) {
    if (sig == SIGINT || sig == SIGTERM) {
        log_message(LOG_LEVEL_INFO, "收到终止信号，正在停止...");
        g_running = false;
    }
}

int get_current_dir(char *buffer, size_t size) {
    if (!buffer || size == 0) {
        return -1;
    }
    
    if (!getcwd(buffer, size)) {
        log_message(LOG_LEVEL_ERROR, "无法获取当前工作目录");
        return -1;
    }
    
    return 0;
}

int create_directory(const char *path) {
    struct stat st = {0};
    
    if (stat(path, &st) == -1) {
        // 目录不存在，创建
#ifdef _WIN32
        if (mkdir(path) == -1) {
#else
        if (mkdir(path, 0755) == -1) {
#endif
            log_message(LOG_LEVEL_ERROR, "无法创建目录: %s", path);
            return -1;
        }
        log_message(LOG_LEVEL_INFO, "已创建目录: %s", path);
    }
    
    return 0;
}

bool file_exists(const char *filename) {
    struct stat st;
    return (stat(filename, &st) == 0);
}

void get_formatted_time(char *buffer, size_t size, const char *format) {
    if (!buffer || size == 0 || !format) {
        return;
    }
    
    time_t raw_time;
    struct tm time_info;
    
    time(&raw_time);
    
#ifdef _WIN32
    // Windows平台使用localtime_s
    localtime_s(&time_info, &raw_time);
#else
    // POSIX平台使用localtime_r
    localtime_r(&raw_time, &time_info);
#endif
    
    strftime(buffer, size, format, &time_info);
}

// 实现cleanup_system_utils函数
void cleanup_system_utils(void) {
    static bool already_cleaned = false;
    
    if (already_cleaned) {
        return;
    }
    
    already_cleaned = true;
    
    // 调用内部清理函数
    internal_cleanup_system();
    
    // 调用logger清理函数以确保兼容性
    cleanup_logger();
    
    log_message(LOG_LEVEL_INFO, "系统工具资源已清理");
}

// 初始化系统工具（日志等）
int init_system_utils(const char *log_file, LogLevel log_level) {
    // 设置日志级别
    set_log_level(log_level);
    
    // 打开日志文件
    if (log_file && strlen(log_file) > 0) {
        log_file_handle = fopen(log_file, "a");
        if (!log_file_handle) {
            fprintf(stderr, "无法打开日志文件: %s\n", log_file);
            // 继续执行，只是不写日志文件
        }
        
        // 更新g_logger以保持兼容性
        g_logger.log_file = log_file_handle;
        g_logger.initialized = true;
    }
    
    // 初始化FFmpeg网络功能
    avformat_network_init();
    
    // 设置信号处理
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    signal(SIGPIPE, SIG_IGN); // 忽略管道错误信号
    
    log_message(LOG_LEVEL_INFO, "系统工具已初始化");
    return 0;
}

// ========================= 以下是整合自system_diagnostics.c的内容 =========================

// 全局诊断状态
static DiagnosticsState g_diagnostics_state = {0};

// 诊断线程
static pthread_t g_diagnostics_thread;
static bool g_diagnostics_running = false;

// 看门狗定时器
static pthread_t g_watchdog_thread;
static bool g_watchdog_running = false;
static uint64_t g_last_watchdog_reset = 0;
static const uint64_t WATCHDOG_TIMEOUT_MS = 30000;  // 30秒超时

// 组件名称表
static const char* g_component_names[] = {
    "系统",
    "传感器",
    "视觉",
    "立体视觉",
    "存储",
    "网络"
};

// 健康状态名称表
static const char* g_health_status_names[] = {
    "未知",
    "正常",
    "警告",
    "错误",
    "严重错误"
};

// 前向声明
static void* diagnostics_thread_func(void* arg);
static void* watchdog_thread_func(void* arg);
static int check_system_resources(void);
static int check_component_health(SystemComponent component);
static bool should_recover_component(SystemComponent component);

/**
 * @brief 初始化系统诊断模块
 * 
 * @param enable_watchdog 是否启用看门狗
 * @return int 成功返回0，失败返回非0
 */
int init_diagnostics(bool enable_watchdog) {
    log_message(LOG_LEVEL_INFO, "初始化系统诊断模块");
    
    // 初始化诊断状态
    memset(&g_diagnostics_state, 0, sizeof(DiagnosticsState));
    
    // 设置初始组件状态
    for (int i = 0; i < COMPONENT_COUNT; i++) {
        g_diagnostics_state.components[i].health = HEALTH_UNKNOWN;
        g_diagnostics_state.components[i].health_score = 100;  // 默认满分
        g_diagnostics_state.components[i].last_check_time = 0;
        snprintf(g_diagnostics_state.components[i].status_message, 
                sizeof(g_diagnostics_state.components[i].status_message), 
                "未初始化");
    }
    
    // 设置看门狗状态
    g_diagnostics_state.watchdog_enabled = enable_watchdog;
    g_diagnostics_state.watchdog_reset_count = 0;
    g_last_watchdog_reset = get_timestamp_ms();
    
    // 记录启动时间
    g_diagnostics_state.uptime_ms = 0;
    g_diagnostics_state.last_diagnostics_time = g_last_watchdog_reset;
    
    return 0;
}

/**
 * @brief 清理系统诊断模块
 */
void cleanup_diagnostics(void) {
    log_message(LOG_LEVEL_INFO, "清理系统诊断模块");
    
    // 停止诊断线程
    stop_diagnostics_thread();
}

/**
 * @brief 启动诊断线程
 * 
 * @return int 成功返回0，失败返回非0
 */
int start_diagnostics_thread(void) {
    // 如果线程已经在运行，直接返回
    if (g_diagnostics_running) {
        return 0;
    }
    
    log_message(LOG_LEVEL_INFO, "启动系统诊断线程");
    
    // 设置运行标志
    g_diagnostics_running = true;
    
    // 创建诊断线程
    int ret = create_thread(&g_diagnostics_thread, diagnostics_thread_func, NULL, "诊断线程");
    if (ret != 0) {
        log_message(LOG_LEVEL_ERROR, "创建诊断线程失败: %d", ret);
        g_diagnostics_running = false;
        return ret;
    }
    
    // 如果启用了看门狗，则创建看门狗线程
    if (g_diagnostics_state.watchdog_enabled) {
        g_watchdog_running = true;
        ret = create_thread(&g_watchdog_thread, watchdog_thread_func, NULL, "看门狗线程");
        if (ret != 0) {
            log_message(LOG_LEVEL_ERROR, "创建看门狗线程失败: %d", ret);
            g_watchdog_running = false;
            // 即使看门狗线程创建失败，也继续运行诊断线程
        } else {
            log_message(LOG_LEVEL_INFO, "看门狗监控已启动，超时时间: %lu ms", WATCHDOG_TIMEOUT_MS);
        }
    }
    
    return 0;
}

/**
 * @brief 停止诊断线程
 * 
 * @return int 成功返回0，失败返回非0
 */
int stop_diagnostics_thread(void) {
    // 如果线程未运行，直接返回
    if (!g_diagnostics_running) {
        return 0;
    }
    
    log_message(LOG_LEVEL_INFO, "停止系统诊断线程");
    
    // 设置停止标志
    g_diagnostics_running = false;
    
    // 等待线程结束
    int ret = join_thread(g_diagnostics_thread, NULL);
    if (ret != 0) {
        log_message(LOG_LEVEL_ERROR, "等待诊断线程结束失败: %d", ret);
    }
    
    // 如果看门狗线程在运行，也停止它
    if (g_watchdog_running) {
        g_watchdog_running = false;
        ret = join_thread(g_watchdog_thread, NULL);
        if (ret != 0) {
            log_message(LOG_LEVEL_ERROR, "等待看门狗线程结束失败: %d", ret);
        }
    }
    
    return 0;
}

/**
 * @brief 诊断线程函数
 * 
 * @param arg 线程参数
 * @return void* 线程返回值
 */
static void* diagnostics_thread_func(void* arg) {
    log_message(LOG_LEVEL_INFO, "诊断线程已启动");
    
    // 初始间隔设为3秒
    uint64_t check_interval_ms = 3000;
    uint64_t last_check_time = get_timestamp_ms();
    uint64_t last_full_check_time = last_check_time;
    const uint64_t FULL_CHECK_INTERVAL_MS = 60000;  // 完整检查间隔: 1分钟
    
    while (g_diagnostics_running) {
        uint64_t current_time = get_timestamp_ms();
        
        // 更新系统运行时间
        g_diagnostics_state.uptime_ms = current_time - g_last_watchdog_reset;
        
        // 检查是否需要执行诊断
        if (current_time - last_check_time >= check_interval_ms) {
            // 更新资源使用情况
            check_system_resources();
            
            // 检查各组件状态
            for (int i = 0; i < COMPONENT_COUNT; i++) {
                // 周期性执行完整检查，其他时间只做简单检查
                bool is_full_check = (current_time - last_full_check_time >= FULL_CHECK_INTERVAL_MS);
                if (is_full_check) {
                    // 执行完整健康检查
                    check_component_health(i);
                    
                    // 检查是否需要恢复
                    if (should_recover_component(i)) {
                        g_diagnostics_state.components[i].recovery_in_progress = true;
                        bool recovered = try_recover_component(i);
                        if (recovered) {
                            log_message(LOG_LEVEL_INFO, 
                                     "组件[%s]恢复成功", 
                                     get_component_name(i));
                        } else {
                            log_message(LOG_LEVEL_ERROR, 
                                     "组件[%s]恢复失败，需要人工干预", 
                                     get_component_name(i));
                        }
                        g_diagnostics_state.components[i].recovery_in_progress = false;
                    }
                }
            }
            
            // 如果进行了完整检查，更新最后完整检查时间
            if (current_time - last_full_check_time >= FULL_CHECK_INTERVAL_MS) {
                last_full_check_time = current_time;
                
                // 发布系统健康状态报告
                HealthStatus system_health = get_system_health();
                uint8_t system_score = get_system_health_score();
                
                log_message(LOG_LEVEL_INFO, 
                         "系统健康状态: %s, 得分: %d/100, 运行时间: %.2f小时", 
                         get_health_status_name(system_health),
                         system_score,
                         g_diagnostics_state.uptime_ms / 3600000.0);
            }
            
            // 更新最后检查时间
            last_check_time = current_time;
            g_diagnostics_state.last_diagnostics_time = current_time;
            
            // 根据系统状态动态调整检查间隔
            if (get_system_health() <= HEALTH_NORMAL) {
                check_interval_ms = 5000;  // 正常状态下5秒检查一次
            } else {
                check_interval_ms = 2000;  // 异常状态下2秒检查一次
            }
        }
        
        // 短暂休眠，降低CPU占用
        thread_sleep(200);
    }
    
    log_message(LOG_LEVEL_INFO, "诊断线程已停止");
    return NULL;
}

/**
 * @brief 看门狗线程函数
 * 
 * @param arg 线程参数
 * @return void* 线程返回值
 */
static void* watchdog_thread_func(void* arg) {
    log_message(LOG_LEVEL_INFO, "看门狗线程已启动");
    
    while (g_watchdog_running) {
        uint64_t current_time = get_timestamp_ms();
        
        // 检查是否超时
        if (current_time - g_last_watchdog_reset > WATCHDOG_TIMEOUT_MS) {
            log_message(LOG_LEVEL_WARNING, 
                     "看门狗超时! 上次复位时间: %lu ms前, 将重启系统", 
                     current_time - g_last_watchdog_reset);
            
            // 增加重置计数
            g_diagnostics_state.watchdog_reset_count++;
            
            // 在实际应用中可以在这里重启系统或触发其他恢复操作
            // 但为了安全，这里只记录日志
            g_last_watchdog_reset = current_time;
        }
        
        // 短暂休眠，降低CPU占用
        thread_sleep(1000);
    }
    
    log_message(LOG_LEVEL_INFO, "看门狗线程已停止");
    return NULL;
}

/**
 * @brief 执行系统诊断
 * 
 * @param full_diagnostics 是否执行完整诊断
 * @return int 成功返回0，失败返回非0
 */
int perform_diagnostics(bool full_diagnostics) {
    int ret = 0;
    
    // 更新资源使用情况
    ret = check_system_resources();
    if (ret != 0) {
        log_message(LOG_LEVEL_WARNING, "获取系统资源使用情况失败");
    }
    
    // 检查各组件状态
    for (int i = 0; i < COMPONENT_COUNT; i++) {
        if (check_component_health(i) != 0) {
            ret = -1;
        }
    }
    
    // 更新诊断时间
    g_diagnostics_state.last_diagnostics_time = get_timestamp_ms();
    
    return ret;
}

/**
 * @brief 获取系统诊断状态
 * 
 * @param state 输出状态结构体指针
 * @return int 成功返回0，失败返回非0
 */
int get_diagnostics_state(DiagnosticsState *state) {
    if (!state) {
        return -1;
    }
    
    // 复制诊断状态
    memcpy(state, &g_diagnostics_state, sizeof(DiagnosticsState));
    
    return 0;
}

/**
 * @brief 获取组件健康状态
 * 
 * @param component 组件枚举值
 * @return HealthStatus 健康状态
 */
HealthStatus get_component_health(SystemComponent component) {
    if (component >= COMPONENT_COUNT) {
        return HEALTH_UNKNOWN;
    }
    
    return g_diagnostics_state.components[component].health;
}

/**
 * @brief 获取组件健康分数(0-100)
 * 
 * @param component 组件枚举值
 * @return uint8_t 健康分数
 */
uint8_t get_component_health_score(SystemComponent component) {
    if (component >= COMPONENT_COUNT) {
        return 0;
    }
    
    return g_diagnostics_state.components[component].health_score;
}

/**
 * @brief 获取系统整体健康状态
 * 
 * @return HealthStatus 健康状态
 */
HealthStatus get_system_health(void) {
    return get_component_health(COMPONENT_SYSTEM);
}

/**
 * @brief 获取系统整体健康分数(0-100)
 * 
 * @return uint8_t 健康分数
 */
uint8_t get_system_health_score(void) {
    return get_component_health_score(COMPONENT_SYSTEM);
}

/**
 * @brief 重置看门狗计时器
 * 必须定期调用此函数，否则系统会自动重启
 */
void reset_watchdog(void) {
    if (g_diagnostics_state.watchdog_enabled) {
        g_last_watchdog_reset = get_timestamp_ms();
    }
}

/**
 * @brief 尝试自动恢复组件
 * 
 * @param component 组件枚举值
 * @return bool 成功返回true，失败返回false
 */
bool try_recover_component(SystemComponent component) {
    if (component >= COMPONENT_COUNT) {
        return false;
    }
    
    // 只有在需要恢复且不在恢复过程中时才尝试恢复
    if (!g_diagnostics_state.components[component].recovery_needed ||
        g_diagnostics_state.components[component].recovery_in_progress) {
        return false;
    }
    
    log_message(LOG_LEVEL_INFO, "尝试恢复组件: %s", get_component_name(component));
    
    bool recovered = false;
    
    // 基于组件类型执行不同的恢复操作
    switch (component) {
        case COMPONENT_SYSTEM:
            // 系统级恢复，可能需要重新初始化或重启某些模块
            // 这里仅作为示例
            log_message(LOG_LEVEL_INFO, "执行系统级恢复...");
            
            // 重置所有组件的恢复标志
            for (int i = 0; i < COMPONENT_COUNT; i++) {
                g_diagnostics_state.components[i].recovery_needed = false;
            }
            
            recovered = true;
            break;
            
        case COMPONENT_SENSOR:
            // 尝试重新初始化传感器
            log_message(LOG_LEVEL_INFO, "尝试重新初始化传感器...");
            // 这里需要具体实现传感器重新初始化的代码
            // 例如: if (reinit_sensors() == 0) recovered = true;
            recovered = true;
            break;
            
        case COMPONENT_VISUAL:
            // 尝试重新初始化视觉系统
            log_message(LOG_LEVEL_INFO, "尝试重新初始化视觉系统...");
            // 这里需要具体实现视觉系统重新初始化的代码
            // 例如: if (reinit_visual_system() == 0) recovered = true;
            recovered = true;
            break;
            
        case COMPONENT_STEREO:
            // 尝试重新初始化立体视觉系统
            log_message(LOG_LEVEL_INFO, "尝试重新初始化立体视觉系统...");
            // 这里需要具体实现立体视觉系统重新初始化的代码
            // 例如: if (reinit_stereo_system() == 0) recovered = true;
            recovered = true;
            break;
            
        case COMPONENT_STORAGE:
            // 尝试修复存储问题
            log_message(LOG_LEVEL_INFO, "尝试修复存储系统...");
            // 这里需要具体实现存储系统修复的代码
            // 例如: if (repair_storage_system() == 0) recovered = true;
            recovered = true;
            break;
            
        case COMPONENT_NETWORK:
            // 尝试重新初始化网络
            log_message(LOG_LEVEL_INFO, "尝试重新初始化网络连接...");
            // 这里需要具体实现网络重新初始化的代码
            // 例如: if (reinit_network() == 0) recovered = true;
            recovered = true;
            break;
            
        default:
            log_message(LOG_LEVEL_ERROR, "未知组件类型: %d", component);
            break;
    }
    
    // 更新恢复状态
    if (recovered) {
        g_diagnostics_state.components[component].recovery_needed = false;
        g_diagnostics_state.components[component].health_score += 20;
        if (g_diagnostics_state.components[component].health_score > 100) {
            g_diagnostics_state.components[component].health_score = 100;
        }
        
        if (g_diagnostics_state.components[component].health_score >= 60) {
            g_diagnostics_state.components[component].health = HEALTH_NORMAL;
        } else if (g_diagnostics_state.components[component].health_score >= 40) {
            g_diagnostics_state.components[component].health = HEALTH_WARNING;
        }
        
        log_message(LOG_LEVEL_INFO, "组件[%s]恢复成功，当前健康分数: %d", 
                  get_component_name(component),
                  g_diagnostics_state.components[component].health_score);
    } else {
        // 恢复失败，增加错误计数
        g_diagnostics_state.components[component].error_count++;
        g_diagnostics_state.components[component].health_score -= 5;
        if (g_diagnostics_state.components[component].health_score < 0) {
            g_diagnostics_state.components[component].health_score = 0;
        }
        
        log_message(LOG_LEVEL_ERROR, "组件[%s]恢复失败，当前健康分数: %d", 
                  get_component_name(component),
                  g_diagnostics_state.components[component].health_score);
    }
    
    return recovered;
}

/**
 * @brief 获取系统资源使用情况
 * 
 * @param resources 输出资源结构体指针
 * @return int 成功返回0，失败返回非0
 */
int get_system_resources(SystemResources *resources) {
    if (!resources) {
        return -1;
    }
    
    // 复制资源使用情况
    memcpy(resources, &g_diagnostics_state.resources, sizeof(SystemResources));
    
    return 0;
}

/**
 * @brief 记录诊断事件
 * 
 * @param component 组件枚举值
 * @param status 健康状态
 * @param format 消息格式
 * @param ... 可变参数
 */
void log_diagnostic_event(SystemComponent component, HealthStatus status, const char *format, ...) {
    if (component >= COMPONENT_COUNT) {
        return;
    }
    
    // 更新组件状态
    g_diagnostics_state.components[component].health = status;
    g_diagnostics_state.components[component].last_check_time = get_timestamp_ms();
    
    // 根据状态调整健康分数
    switch (status) {
        case HEALTH_NORMAL:
            // 正常状态，不修改分数
            break;
        case HEALTH_WARNING:
            // 警告状态，减少分数
            g_diagnostics_state.components[component].warning_count++;
            g_diagnostics_state.components[component].health_score -= 5;
            break;
        case HEALTH_ERROR:
            // 错误状态，显著减少分数
            g_diagnostics_state.components[component].error_count++;
            g_diagnostics_state.components[component].health_score -= 15;
            break;
        case HEALTH_CRITICAL:
            // 严重错误，健康分数降为0
            g_diagnostics_state.components[component].error_count++;
            g_diagnostics_state.components[component].health_score = 0;
            break;
        default:
            break;
    }
    
    // 确保健康分数在有效范围内
    if (g_diagnostics_state.components[component].health_score < 0) {
        g_diagnostics_state.components[component].health_score = 0;
    } else if (g_diagnostics_state.components[component].health_score > 100) {
        g_diagnostics_state.components[component].health_score = 100;
    }
    
    // 设置恢复标志
    if (status == HEALTH_ERROR || status == HEALTH_CRITICAL) {
        g_diagnostics_state.components[component].recovery_needed = true;
    }
    
    // 格式化消息
    va_list args;
    va_start(args, format);
    char message[256];
    vsnprintf(message, sizeof(message), format, args);
    va_end(args);
    
    // 更新状态消息
    snprintf(g_diagnostics_state.components[component].status_message, 
            sizeof(g_diagnostics_state.components[component].status_message), 
            "%s", message);
    
    // 根据状态级别输出日志
    LogLevel log_level;
    switch (status) {
        case HEALTH_NORMAL:
            log_level = LOG_LEVEL_INFO;
            break;
        case HEALTH_WARNING:
            log_level = LOG_LEVEL_WARNING;
            break;
        case HEALTH_ERROR:
        case HEALTH_CRITICAL:
            log_level = LOG_LEVEL_ERROR;
            break;
        default:
            log_level = LOG_LEVEL_DEBUG;
            break;
    }
    
    log_message(log_level, "[%s] %s", get_component_name(component), message);
}

/**
 * @brief 获取组件名称
 * 
 * @param component 组件枚举值
 * @return const char* 组件名称字符串
 */
const char* get_component_name(SystemComponent component) {
    if (component >= COMPONENT_COUNT) {
        return "未知组件";
    }
    
    return g_component_names[component];
}

/**
 * @brief 获取健康状态名称
 * 
 * @param status 健康状态枚举值
 * @return const char* 健康状态名称字符串
 */
const char* get_health_status_name(HealthStatus status) {
    if (status < HEALTH_UNKNOWN || status > HEALTH_CRITICAL) {
        return "无效状态";
    }
    
    return g_health_status_names[status];
}

/**
 * @brief 检查系统资源使用情况
 * 
 * @return int 成功返回0，失败返回非0
 */
static int check_system_resources(void) {
    SystemResources *resources = &g_diagnostics_state.resources;
    
    // 使用statvfs获取磁盘空间信息
    struct statvfs fs_info;
    if (statvfs(".", &fs_info) == 0) {
        // 计算磁盘使用率
        uint64_t total_space = (uint64_t)fs_info.f_blocks * fs_info.f_frsize;
        uint64_t free_space = (uint64_t)fs_info.f_bfree * fs_info.f_frsize;
        
        if (total_space > 0) {
            resources->disk_usage = 100.0f * (1.0f - ((float)free_space / total_space));
        }
        
        resources->free_disk_space = free_space;
        
        // 检查磁盘空间是否不足
        if (resources->disk_usage > 90.0f) {
            log_diagnostic_event(COMPONENT_STORAGE, HEALTH_WARNING, 
                               "磁盘空间使用率过高: %.1f%%", resources->disk_usage);
        } else if (resources->disk_usage > 95.0f) {
            log_diagnostic_event(COMPONENT_STORAGE, HEALTH_ERROR, 
                               "磁盘空间严重不足: %.1f%%", resources->disk_usage);
        }
    } else {
        log_message(LOG_LEVEL_ERROR, "获取磁盘空间信息失败");
        return -1;
    }
    
    // CPU使用率和内存使用率的获取在不同平台上实现方式不同
    // 这里应该根据实际平台添加相应的代码
    // 这里仅作为示例，使用模拟数据
    resources->cpu_usage = 30.0f;  // 假设30%的CPU使用率
    resources->memory_usage = 40.0f;  // 假设40%的内存使用率
    
    // 在实际应用中可以添加对CPU和内存使用率的检查
    if (resources->cpu_usage > 80.0f) {
        log_diagnostic_event(COMPONENT_SYSTEM, HEALTH_WARNING, 
                           "CPU使用率过高: %.1f%%", resources->cpu_usage);
    }
    
    if (resources->memory_usage > 80.0f) {
        log_diagnostic_event(COMPONENT_SYSTEM, HEALTH_WARNING, 
                           "内存使用率过高: %.1f%%", resources->memory_usage);
    }
    
    return 0;
}

/**
 * @brief 检查组件健康状态
 * 
 * @param component 组件枚举值
 * @return int 成功返回0，失败返回非0
 */
static int check_component_health(SystemComponent component) {
    if (component >= COMPONENT_COUNT) {
        return -1;
    }
    
    // 根据组件类型执行不同的检查
    switch (component) {
        case COMPONENT_SYSTEM:
            // 检查系统整体状态
            {
                // 计算系统健康得分 - 基于所有其他组件的平均分
                int sum_score = 0;
                int valid_components = 0;
                
                for (int i = 1; i < COMPONENT_COUNT; i++) {  // 从1开始，跳过系统组件本身
                    if (g_diagnostics_state.components[i].health != HEALTH_UNKNOWN) {
                        sum_score += g_diagnostics_state.components[i].health_score;
                        valid_components++;
                    }
                }
                
                if (valid_components > 0) {
                    g_diagnostics_state.components[COMPONENT_SYSTEM].health_score = sum_score / valid_components;
                }
                
                // 根据得分确定健康状态
                uint8_t score = g_diagnostics_state.components[COMPONENT_SYSTEM].health_score;
                if (score >= 80) {
                    g_diagnostics_state.components[COMPONENT_SYSTEM].health = HEALTH_NORMAL;
                } else if (score >= 60) {
                    g_diagnostics_state.components[COMPONENT_SYSTEM].health = HEALTH_WARNING;
                } else if (score >= 30) {
                    g_diagnostics_state.components[COMPONENT_SYSTEM].health = HEALTH_ERROR;
                } else {
                    g_diagnostics_state.components[COMPONENT_SYSTEM].health = HEALTH_CRITICAL;
                }
            }
            break;
            
        case COMPONENT_SENSOR:
        case COMPONENT_VISUAL:
        case COMPONENT_STEREO:
        case COMPONENT_STORAGE:
        case COMPONENT_NETWORK:
            // 对于其他组件，可以在这里添加特定的检查逻辑
            // 这里作为示例，仅演示如何更新状态，实际应用中需要具体实现
            break;
            
        default:
            return -1;
    }
    
    return 0;
}

/**
 * @brief 判断组件是否需要恢复
 * 
 * @param component 组件枚举值
 * @return true 需要恢复
 * @return false 不需要恢复
 */
static bool should_recover_component(SystemComponent component) {
    if (component >= COMPONENT_COUNT) {
        return false;
    }
    
    // 如果组件标记为需要恢复，且当前不在恢复过程中，则尝试恢复
    if (g_diagnostics_state.components[component].recovery_needed &&
        !g_diagnostics_state.components[component].recovery_in_progress) {
        return true;
    }
    
    return false;
} 